home *** CD-ROM | disk | FTP | other *** search
/ TOS Silver 2000 / TOS Silver 2000.iso / Anwendun / 7UP_PD / GREPFILE.C < prev    next >
Encoding:
C/C++ Source or Header  |  1997-01-17  |  11.3 KB  |  466 lines
  1. /* Durchsucht Dateien nach Mustern */
  2. /*****************************************************************************
  3. *
  4. *                                              7UP
  5. *                                      Modul: GREPFILE.C
  6. *                                     (c) by TheoSoft '92
  7. *
  8. *****************************************************************************/
  9. #include <portab.h>
  10. #include <stdio.h>
  11. #include <stdlib.h>
  12. #include <string.h>
  13. #include <aes.h>
  14.  
  15. #if GEMDOS
  16. #include <tos.h>
  17. #include <ext.h>
  18. #include "fsel_inp.c"
  19. #else
  20. #include <dir.h>
  21. #endif
  22.  
  23. #include "forms.h"
  24. #include "windows.h"
  25. #include "7up.h"
  26. #include "version.h"
  27. #include "alert.h"
  28. /*
  29. #define VERSIONNAME    "7UP 2.11 © 1991,92 bei TheoSoft"
  30. */
  31. #define MAXPATHS 7
  32. #define ESC 0x01
  33. #define WM_BACKDROPPED    31        /* Message vom Eventhandler */
  34. #define FILEIOBUFF (32*1024L)
  35.  
  36. int    compile(char *);
  37. int    icompile(char *);
  38. char *grep(char *,char *,int *);
  39. char *igrep(char *,char *,int *);
  40. char *split_fname(char *filename);
  41. WINDOW *Wreadtempfile(char *filename, int mode);
  42. char *stradj(char *dest, char *src, int maxlen);
  43. long tfork(int cdecl (*func)(long), long arg);
  44.  
  45. extern OBJECT *findmenu,*grepmenu;
  46. extern char alertstr[],iostring[],iostr2[],searchstring[];
  47. extern int cut;
  48. extern LINESTRUCT *begcut,*endcut;
  49.  
  50. static char pattern[FILENAME_MAX],filename[PATH_MAX];
  51. static int all,files,folders,abbruch=FALSE,Xmode=FALSE;
  52. static long found;
  53. static FILE *gp;
  54. static int msgbuf[8];
  55.  
  56. static MEVENT mevent=
  57. {
  58.     MU_TIMER|MU_KEYBD|MU_MESAG,
  59.     0,0,0,
  60.     0,0,0,0,0,
  61.     0,0,0,0,0,
  62.     msgbuf,
  63.     0L,
  64.     0,0,0,0,0,0,
  65. /* nur der Vollständigkeit halber die Variablen von XGEM */
  66.     0,0,0,0,0,
  67.     0,
  68.     0L,
  69.     0L,0L
  70. };
  71.  
  72. static char *stradj(char *dest, char *src, int maxlen)
  73. {
  74.     register int len;
  75.     if((len=strlen(src))>maxlen)
  76.     {
  77.         strncpy(dest,src,maxlen/2);
  78.         strncpy(&dest[maxlen/2],&src[len-maxlen/2],maxlen/2);
  79.         dest[maxlen/2-1]='.';
  80.         dest[maxlen/2+0]='.';
  81.         dest[maxlen/2+1]='.';
  82.         return(dest);
  83.     }
  84.     return(src);
  85. }
  86.  
  87. static int grepfile(OBJECT *tree, char *fname)
  88. {
  89.     FILE *fp=NULL;
  90.     int dummy,event,line=0,len,f=0;
  91.     char *cp, string[29];
  92.     WINDOW *wp;
  93.     extern int dial_handle;
  94.  
  95.     event=evnt_event(&mevent);
  96.     wind_update(BEG_UPDATE);
  97.     if(event & MU_MESAG)
  98.     {
  99.         if((msgbuf[0] != MN_SELECTED) && (msgbuf[0] < 50)) /* AP_TERM */
  100.         {
  101.             if(msgbuf[3]==dial_handle) /* Dialogfenster */
  102.             {
  103.                 switch(msgbuf[0])
  104.                 {
  105.                     case WM_BACKDROPPED: /* nein, niemals */
  106.                         break;
  107.                     case WM_REDRAW:
  108.                         fwind_redraw(tree,msgbuf[3],&msgbuf[4]);
  109.                         break;
  110.                     case WM_MOVED:
  111.                         fwind_move(tree,msgbuf[3],&msgbuf[4]);
  112.                         break;
  113.                     case WM_TOPPED:
  114.                         wind_set(msgbuf[3],WF_TOP,0,0,0,0);
  115.                         break;
  116.                 }
  117.             }
  118.             else /* aber kein Schließen oder Toppen */
  119.                 if(msgbuf[0]!=WM_CLOSED && msgbuf[0]!=WM_TOPPED)
  120.                     Wwindmsg(Wp(msgbuf[3]),msgbuf);
  121.         }
  122.     }
  123.     if(event&MU_KEYBD)
  124.     {
  125.         if((mevent.e_kr>>8)==ESC)                             /* ESC gedrückt? */
  126.             if(form_alert(2,Agrepfile[0])==2)
  127.                 abbruch=TRUE;
  128.     }
  129.     wind_update(END_UPDATE);
  130.  
  131.     if(!(tree[GREPGREP].ob_state&SELECTED)) /* normal suchen */
  132.     {
  133.         form_read(tree,GREPPATT,alertstr);
  134.         len=strlen(alertstr);
  135.     }
  136.  
  137.     if(!abbruch && (fp=fopen(fname,"r"))!=NULL)
  138.     {
  139. #if GEMDOS
  140.         setvbuf(fp,NULL,_IOFBF,min(filelength(fileno(fp)),FILEIOBUFF));
  141. #endif
  142. /*
  143.       form_write(tree,GREPNAME,strlen(fname)>28?&fname[strlen(fname)-28]:fname,TRUE);/* Namen einblenden */
  144. */
  145.       form_write(tree,GREPNAME,stradj(string, fname, 28),TRUE);/* Namen einblenden */
  146.       
  147.         while(fgets(iostr2,STRING_LENGTH+2,fp)!=NULL)
  148.         {
  149.             line++;
  150.             stpexpan(iostring,iostr2,((wp=Wgettop())!=NULL)?wp->tab:3,STRING_LENGTH,&dummy);
  151.  
  152.          if(tree[GREPGREP].ob_state&SELECTED)
  153.                cp=grep(iostring,iostring,&len); /* reguläre Ausdrücke */
  154.             else
  155.                cp=strstr(iostring,alertstr);         /* normal suchen */
  156. /*
  157.             cp=grep(iostring,iostring,&len);
  158. */
  159.          if(cp)
  160.             {
  161.                 if(!f)
  162.                 {
  163.                     fprintf(gp,"\nDatei %s\n",fname);
  164.                     files++;
  165.                 }
  166.                 found++;
  167.                 f++;
  168.                 fprintf(gp,"%-4d %-3d %-3d: %s",line,(int)(cp-iostring)+1,len,iostring);
  169.                 if(!all)
  170.                 {
  171.                     fclose(fp);
  172.                     return(f);
  173.                 }
  174.             }
  175.         }
  176.         if(f)
  177.             fprintf(gp,"%d Textstelle(n)\n",f);
  178.         fclose(fp);
  179.     }
  180.     return(f);
  181. }
  182.  
  183. static char lfilename[PATH_MAX];
  184.  
  185. static int walktree(OBJECT *tree,char *path)
  186. {
  187.     struct ffblk l_dta;
  188.     char l_name[100];
  189.  
  190.     sprintf(l_name,"%s%s",path,pattern);
  191.     if(!findfirst(l_name,&l_dta,0))
  192.     {
  193.         sprintf(filename,"%s%s",path,l_dta.ff_name);
  194.         /*31.12.95*/
  195.         if(strcmp(filename, lfilename))/*Zieldatei nicht nochmal bewerten!*/
  196.             grepfile(tree,filename);
  197.         
  198.         while(!findnext(&l_dta))
  199.         {
  200.             sprintf(filename,"%s%s",path,l_dta.ff_name);
  201.             /*31.12.95*/
  202.             if(strcmp(filename, lfilename))/*Zieldatei nicht nochmal bewerten!*/
  203.                 grepfile(tree,filename);
  204.         }
  205.     }
  206.     if(!(grepmenu[GREPFOLD].ob_state & SELECTED))
  207.         return;
  208.     sprintf(l_name,"%s*.*",path);
  209.     if(!findfirst(l_name,&l_dta,0x10))
  210.     {
  211.         if(l_dta.ff_attrib & 0x10)
  212.             if(strcmp(l_dta.ff_name,".") && strcmp(l_dta.ff_name,".."))
  213.             {
  214.                 folders++;
  215.                 if(Xmode)
  216.                     sprintf(l_name,"%s%s/",path,l_dta.ff_name);
  217.                 else
  218.                     sprintf(l_name,"%s%s\\",path,l_dta.ff_name);
  219.                 walktree(tree,l_name);
  220.             }
  221.             while(!findnext(&l_dta))
  222.             {
  223.                 if(l_dta.ff_attrib & 0x10)
  224.                     if(strcmp(l_dta.ff_name,".") && strcmp(l_dta.ff_name,".."))
  225.                     {
  226.                         folders++;
  227.                         if(Xmode)
  228.                             sprintf(l_name,"%s%s/",path,l_dta.ff_name);
  229.                         else
  230.                             sprintf(l_name,"%s%s\\",path,l_dta.ff_name);
  231.                         walktree(tree,l_name);
  232.                     }
  233.           }
  234.      }
  235. }
  236.  
  237. char lpath[MAXPATHS][PATH_MAX]={"","","","","","",""};
  238. char *lname[MAXPATHS]={lpath[0],lpath[1],lpath[2],lpath[3],lpath[4],lpath[5],lpath[6]};
  239.  
  240. void hndl_grepmenu(OBJECT *tree, int start)
  241. {
  242.     int a,b,c,i,exit_obj,thread=FALSE;
  243.  
  244.     char *cp,pathname[PATH_MAX],openmodus[2];
  245.  
  246.     int done=FALSE,ret,kstate;
  247.     /*static*/ char fpattern[FILENAME_MAX]="*.*";
  248.     /*static*/ char gpattern[FILENAME_MAX]="*.REG";
  249.    extern int windials;
  250.    
  251.     all=found=files=folders=0;
  252.     a=tree[GREPALL ].ob_state;
  253.     b=tree[GREPFOLD].ob_state;
  254.     c=tree[GREPMARK].ob_state;
  255.     abbruch=FALSE;
  256. /*
  257.     if(getenv("UNIXMODE")!=NULL)
  258.         Xmode=TRUE;
  259.     else
  260. */
  261.        Xmode=FALSE;
  262. /*    
  263.     local.tree=tree;
  264. */    
  265.     if(begcut && endcut && begcut==endcut && endcut->begcol<endcut->used)
  266.     {
  267.          strncpy(alertstr,&begcut->string[begcut->begcol],begcut->endcol-begcut->begcol);
  268.          alertstr[begcut->endcol-begcut->begcol]=0;
  269.          alertstr[tree[GREPPATT].ob_spec.tedinfo->te_txtlen-1]=0;
  270.          form_write(tree,GREPPATT,alertstr,FALSE);
  271.     }
  272. #if GEMDOS
  273.     if( slct_check(0x0100) && tree[GREPMARK].ob_state == DISABLED)
  274.         tree[GREPMARK].ob_state = NORMAL;
  275.     if(!slct_check(0x0100))
  276.         tree[GREPMARK].ob_state = DISABLED;
  277. #else
  278.     tree[GREPMARK].ob_state = DISABLED;
  279. #endif
  280.    form_write(tree,GREPNAME,"",FALSE);/* letzten Namen löschen */
  281.     form_exopen(tree, 0);
  282.     do
  283.     {
  284.         exit_obj=form_exdo(tree, start);
  285.         switch(exit_obj)
  286.         {
  287.             case GREPHELP:
  288.              if(tree[GREPGREP].ob_state&SELECTED) /* bei reg. Exp. */
  289.              {
  290.                    if(form_alert(2,Agrepfile[6])==2)
  291.                       if(form_alert(2,Agrepfile[7])==2)
  292.                           form_alert(1,Agrepfile[8]);
  293.                 }
  294.                 else
  295.                    form_alert(1,Agrepfile[1]);
  296.                 objc_change(tree,exit_obj,0,tree->ob_x,tree->ob_y,tree->ob_width,tree->ob_height,tree[exit_obj].ob_state&~SELECTED,TRUE);
  297.                 break;
  298.             case GREPOK:
  299.                 form_read(tree,GREPPATT,alertstr);
  300.                 if(!(*alertstr))
  301.                 {
  302.                     done=TRUE;
  303.                     break;
  304.                 }
  305.              if(tree[GREPGREP].ob_state&SELECTED) /* regulärer Ausdruck */
  306.                     if(!compile(alertstr)) /* immer kompilieren !!! */
  307.                     {
  308.                         done=TRUE;
  309.                         break;
  310.                     }
  311. #if GEMDOS
  312.                 if(tree[GREPMARK].ob_state & SELECTED)
  313.                 {
  314.                     slct_morenames(0, MAXPATHS,lname); /* we want more */
  315.                     /*local.*/pathname[0]=0;
  316.                     getfilename(/*local.*/pathname,fpattern,"@",fselmsg[17]);
  317.                     if(!/*local.*/pathname[0]) /* Kunde will nicht */
  318.                     {
  319.                         done=TRUE;
  320.                         break;
  321.                     }
  322.                 }
  323.                 else
  324. #endif
  325.                 {
  326.                     for(i=0; i<MAXPATHS; i++)
  327.                     {
  328.                         sprintf(&alertstr[100],"%d. Startverzeichnis/Suchmuster",i+1);
  329.                         *lpath[i]=0;
  330.                         if(!getfilename(lpath[i],fpattern,"@",&alertstr[100]))
  331.                             break;
  332.                     }
  333.                     if(!*lpath[0]) /* Kunde will nicht */
  334.                     {
  335.                         done=TRUE;
  336.                         break;
  337.                     }
  338.                 }
  339.                 /*local.*/lfilename[0]=0;
  340.                 if(getfilename(/*local.*/lfilename,gpattern,"7UP.REG",fselmsg[18]))
  341.                 {
  342.                     if(!windials) /* Hintergrund restaurieren */
  343.                         objc_update(tree,ROOT,MAX_DEPTH);
  344.                     if(!strstr(/*local.*/lfilename,".REG"))
  345.                     {
  346.                         form_alert(1,Agrepfile[3]);
  347.                         done=TRUE;
  348.                         break;
  349.                     }
  350.                     graf_mkstate(&ret,&ret,&ret,&kstate);
  351.                     if(kstate & (K_LSHIFT|K_RSHIFT))        /* bei gedrückter Shifttaste... */
  352.                         strcpy(/*local.*/openmodus,"a");                 /* ans Regfile anhängen,...*/
  353.                     else
  354.                         strcpy(/*local.*/openmodus,"w");                 /* ...sonst neue Datei         */
  355. /*
  356.                     thread=tree[GREPTHREAD].ob_state&SELECTED;
  357.                     if(thread)
  358.                         tfork(_searchfiles, 0L);
  359.                     else
  360.                         _searchfiles(0L);
  361. */                    
  362.                     if((gp=fopen(lfilename,openmodus))!=NULL)
  363.                     {
  364. #if GEMDOS
  365.                         setvbuf(gp,NULL,_IOFBF,FILEIOBUFF/8);
  366. #endif
  367.                         fprintf(gp,"%s\n\n",VERSIONNAME);
  368.                         fprintf(gp,"Gesucht: \"%s\"\n",alertstr);
  369. #if GEMDOS
  370.                         if(tree[GREPMARK].ob_state & SELECTED)
  371.                         {
  372.                             folders=1;
  373.                             for(i=0; i<slct->out_count; i++)
  374.                             {  /* Pfadnamen zusammenbasteln */
  375.                                 if((cp=strrchr(pathname,'\\'))!=NULL || 
  376.                                     (cp=strrchr(pathname,'/'))!=NULL)
  377.                                 {
  378.                                     cp[1]=0;
  379.                                     strcat(pathname,lpath[i]);
  380.                                     all=(tree[GREPALL].ob_state & SELECTED);
  381.                                     grepfile(tree,pathname);
  382.                                 }
  383.                             }
  384.                         }
  385.                         else
  386. #endif
  387.                         {
  388.                             for(i=0; i<MAXPATHS-2 && *lpath[i]; i++)
  389.                             {
  390.                                 if((cp=strrchr(lpath[i],'\\'))!=NULL || 
  391.                                     (cp=strrchr(lpath[i],'/'))!=NULL)
  392.                                 {
  393.                                     strcpy(pattern,cp+1L);
  394.                                     cut_path(lpath[i]);
  395. /*
  396.                                     strcut(lpath[i],'\\');
  397. */
  398.                                     all=(tree[GREPALL].ob_state & SELECTED);
  399.                                     walktree(tree,lpath[i]);
  400.                                 }
  401.                             }
  402.                         }
  403.                         fprintf(gp,"\n%ld Textstelle(n) in %d Datei(en) in %d Ordner(n).\n\n",found,files,folders+1);
  404.                         fclose(gp);
  405.                     }
  406.                     else
  407.                     {
  408.                         sprintf(alertstr,Agrepfile[5],(char *)split_fname(filename));
  409.                         form_alert(1,alertstr);
  410.                     }
  411.                 }
  412.             case GREPABBR:
  413.                 done=TRUE;
  414.                 break;
  415.         }
  416.     }
  417.     while(!done);
  418.     form_exclose(tree, exit_obj, 0);
  419.     if(exit_obj==GREPABBR)
  420.     {
  421.         tree[GREPALL ].ob_state=a;
  422.         tree[GREPFOLD].ob_state=b;
  423.         tree[GREPMARK].ob_state=c;
  424.         return;
  425.     }
  426.     if(files)
  427.     {
  428.         if(!thread)
  429.             Wreadtempfile(/*local.*/lfilename,0);
  430.     }
  431.     else
  432.     {
  433.         unlink(/*local.*/lfilename);
  434.     }
  435. }
  436.  
  437. int prepare(OBJECT *tree, OBJECT *tree2, char *str)
  438. {
  439.     form_write(tree,FINDSTR ,str,FALSE);
  440.     form_write(tree,FINDREPL,"",FALSE);
  441.  
  442.       if(tree2[GREPGREP].ob_state & SELECTED) /* regulärer Ausdruck */
  443.    {
  444.         tree[FINDNORM].ob_state=NORMAL;
  445.         tree[FINDMAT ].ob_state=NORMAL;
  446.         tree[FINDGREP].ob_state=SELECTED;
  447.     }
  448.     else
  449.     {
  450.         tree[FINDNORM].ob_state=SELECTED;
  451.         tree[FINDMAT ].ob_state=NORMAL;
  452.         tree[FINDGREP].ob_state=NORMAL;
  453.     }
  454.     tree[FINDSUCH].ob_state=SELECTED;
  455.     tree[FINDERS ].ob_state=NORMAL;
  456.  
  457.     tree[FINDBLK ].ob_state=DISABLED;
  458.     tree[FINDIGNO].ob_state=SELECTED;
  459.     tree[FINDFORW].ob_state=SELECTED;
  460.     tree[FINDASK ].ob_state=DISABLED;
  461.  
  462.     tree[FINDANF ].ob_state=NORMAL;
  463.     tree[FINDWORD].ob_state=DISABLED;
  464.     tree[FINDBACK].ob_state=DISABLED;
  465.     tree[FINDALL ].ob_state=DISABLED;
  466. }ə
  467.